package com.tangsm.spring.boot.validation.service.impl;

import com.tangsm.spring.boot.validation.domain.entity.User;
import com.tangsm.spring.boot.validation.domain.vo.Page;
import com.tangsm.spring.boot.validation.service.UserService;
import com.tangsm.spring.boot.validation.util.JsonUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Service;

import javax.validation.Valid;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;

/**
 * 用户管理业务接口实现类
 * @author tangsm
 */
@Service
public class UserServiceImpl implements UserService {
    private static final Logger log = LoggerFactory.getLogger(UserServiceImpl.class);

    /**
     * 模拟用户数据
     * <p>final static修饰其实在刚才的实验过程中起作用的只有final。</p>
     * <p>当final修饰变量时，对于基本类型和string，这个变量的值是不能改变的；</p>
     * <p>当修饰其他类型的对象时，final使其引用恒定不变，但是对象自身却可以自由修改变换。</p>
     */
    private static final ConcurrentMap<Integer, User> userMap;

    static {
        userMap = new ConcurrentHashMap<>();
        userMap.put(1, new User(1L, "zhangsan", "123456", "zhangsan@gmail.com"));
        userMap.put(2, new User(1L, "lisi", "123456", "lisi@gmail.com"));
        userMap.put(3, new User(1L, "wangwu", "123456", "wangwu@gmail.com"));
        userMap.put(4, new User(1L, "maliu", "123456", "maliu@gmail.com"));
    }

    /**
     * 根据ID查询
     *
     * @param id 用户ID
     * @return 查询结果
     */
    @Override
    public User get(Integer id) {
        log.info("根据ID查询开始, ID={}", id);
        User user = userMap.get(id);
        log.info(JsonUtils.toStringJson(user));
        return user;
    }

    /**
     * 分页查询
     *
     * @param page 分页参数
     * @return 查询结果集合
     */
    @Override
    public List<User> page(Page<User> page) {
        log.info("分页查询开始, page={}", JsonUtils.toStringJson(page));

        // 原始数据
        List<User> list = new ArrayList<>(userMap.values());

        // 页码
        Integer current = page.getCurrent() == null ? 1 : page.getCurrent();
        // 查询数量
        Integer size = page.getSize() == null ? 2 : page.getSize();

        // 起始数
        int startNum = Math.min(size * current - size, list.size() - 1);
        // 结束数
        int endNum = Math.min(size * current, list.size());

        List<User> subList = list.subList(startNum, endNum);

        log.info("起始数={}, 结束数={}, 响应数据={}", startNum, endNum, subList);

        return subList;
    }

    /**
     * 列表查询
     *
     * @param user 请求参数
     * @return 查询结果集合
     */
    @Override
    public List<User> list(User user) {
        return new ArrayList<>(userMap.values());
    }

    /**
     * 添加
     *
     * @param user 用户实体
     * @return true-成功，false-失败
     */
    @Override
    public boolean add(@Valid User user) {
        log.info("添加用户，User={}", JsonUtils.toStringJson(user));
        // 原始数据
        List<User> list = new ArrayList<>(userMap.values());
        userMap.put(list.size() + 1, user);

        return true;
    }

    /**
     * 修改
     *
     * @param user 用户实体
     * @return true-成功，false-失败
     */
    @Override
    public boolean update(User user) {
        return true;
    }

    /**
     * 删除
     *
     * @param id 用户ID
     * @return true-成功，false-失败
     */
    @Override
    public void del(Integer id) {
        userMap.remove(id);
    }

    /**
     * 批量删除
     *
     * @param ids 用户ID集
     * @return true-成功，false-失败
     */
    @Override
    public void delBatch(String ids) {
        String[] idArray = ids.split(",");
        for (String id : idArray) {
            userMap.remove(Integer.parseInt(id));
        }
    }
}
